/**
 * @author 木心
 * @description: 工具
 */

type union = (string | string | boolean | [] | {})


/**
 * 判断数组中是否包含某个值
 * @param v
 */
Array.prototype.$contains = function (v: union): boolean {
    var that = this
    if (that == null) {
        return false
    }
    for (var i = 0; i < that.length; i++) {
        if (that[i] == v) {
            return true
        }
    }
    return false
};

/**
 *将数组（array）拆分成多个 size 长度的区块，并将这些区块组成一个新数组。 如果array 无法被分割成全部等长的区块，那么最后剩余的元素将组成一个区块。
 * @param size
 */
Array.prototype.$chunk = function (size: number = 1): union[] {
    const that = this
    if(size >= that.length || size <= 0) {
        console.warn('你的传参有问题')
        return  [...that]
    }
    let temp: any[] = [], res = [], index = 1
    for(let item of that) {
        if(index <= size) {
            temp.push(item);
            index ++;
        }else {
            res.push(temp)
            temp = []
            temp.push(item)
            index = 2
        }
    }
    res.push(temp)
    return res
}

/**
 * @description 创建一个新数组，包含原数组中所有的非假值元素。例如false, null,0, "", undefined, 和 NaN 都是被认为是“假值”。
 */
Array.prototype.$compact = function (): union[] {
    const that = this
    return that.filter(r => {
        return (r !== false && r !== true && r !== null && r !== 0 && r !== "" && r !== undefined && r !== NaN)
    })
};

/**
 * @description 创建一个具有唯一array值的数组，每个值不包含在其他给定的数组中。
 * （注：即创建一个新数组，这个数组中的值，为第一个数字（array 参数）排除了给定数组中的值。）
 * 结果值的顺序是由第一个数组中的顺序确定。
 * @param array
 */
Array.prototype.$difference = function (array: union[]): union[] {
    const that = this
    let set2 = new Set(array), res: union[] = []
    for(let item of that) {
        if(!set2.has(item)) {
            res.push(item)
        }
    }
    return res
}
/**
 * 创建一个切片数组，去除array前面的n个元素。（n默认值为1。）
 * @param n
 */
Array.prototype.$dropLeft= function (n: number = 1): union[] {
    const that = this
    let index = 1
    while (index <= n) {
        // 如果数组长度为0就提前退出
        if(that.length === 0) break
        that.shift()
        index ++
    }
    return that
}

/**
 * 创建一个切片数组，去除array尾部的n个元素。（n默认值为1。）
 * @param n
 */
Array.prototype.$dropRight = function (n: number = 1): union[] {
    const that = this
    let index = 1
    while (index <= n) {
        // 如果数组长度为0就提前退出
        if(that.length === 0) break
        that.pop()
        index++
    }
    return that
}

/**
 * 在指定的位置填充指定的字符
 * @param str
 * @param start
 * @param end
 */
Array.prototype.$fill = function (str: union,start = 0,end: number ) {
    var that = this
    if(end<=0 || end>=that.length) end = that.length
    for(let i = 0; i< that.length; i++) {
        if(i >= start && i <=end) {
            that[i] = str
        }
    }
    return that
}

/**
 * 创建唯一值的数组，这个数组包含所有给定数组都包含的元素，使用SameValueZero进行相等性比较。（注：可以理解为给定数组的交集）
 * @param array
 */
Array.prototype.$intersection = function (...array: union[]): union[] {
    const that = this
    return Array.from(new Set( [...that,...array.flat()]))
}

/**
 * 移除数组中的元素
 * @param item
 */
Array.prototype.$remove = function (item: union[]) {
    var that = this
    let res = []
    for(var i = 0; i < that.length; i++) {
        if(item !== that[i]) {
            res.push(that[i])
        }
    }
    return res
}

/**
 * 判断数组下标是否存在
 * @param length
 */
Array.prototype.$at = function (length: number): boolean {
    var that = this
    let len = that.length
    if(length<0 || length > len - 1)  return false
    return true
}